home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / info / gnus.info-1.z / gnus.info-1
Encoding:
GNU Info File  |  1998-05-21  |  49.3 KB  |  1,297 lines
  1. This is Info file ../info/gnus.info, produced by Makeinfo version 1.68
  2. from the input file gnus.texi.
  3.  
  4.    This file documents Gnus, the GNU Emacs newsreader.
  5.  
  6.    Copyright (C) 1995,96 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions.
  20.  
  21. 
  22. File: gnus.info,  Node: Top,  Next: Starting Up,  Up: (dir)
  23.  
  24. The Gnus Newsreader
  25. *******************
  26.  
  27.    You can read news (and mail) from within Emacs by using Gnus.  The
  28. news can be gotten by any nefarious means you can think of--NNTP, local
  29. spool or your mbox file.  All at the same time, if you want to push your
  30. luck.
  31.  
  32.    This manual corresponds to Gnus 5.4.66.
  33.  
  34. * Menu:
  35.  
  36. * Starting Up::           Finding news can be a pain.
  37. * The Group Buffer::      Selecting, subscribing and killing groups.
  38. * The Summary Buffer::    Reading, saving and posting articles.
  39. * The Article Buffer::    Displaying and handling articles.
  40. * Composing Messages::    Information on sending mail and news.
  41. * Select Methods::        Gnus reads all messages from various select methods.
  42. * Scoring::               Assigning values to articles.
  43. * Various::               General purpose settings.
  44. * The End::               Farewell and goodbye.
  45. * Appendices::            Terminology, Emacs intro, FAQ, History, Internals.
  46. * Index::                 Variable, function and concept index.
  47. * Key Index::             Key Index.
  48.  
  49. 
  50. File: gnus.info,  Node: Starting Up,  Next: The Group Buffer,  Prev: Top,  Up: Top
  51.  
  52. Starting Gnus
  53. *************
  54.  
  55.    If your system administrator has set things up properly, starting
  56. Gnus and reading news is extremely easy--you just type `M-x gnus' in
  57. your Emacs.
  58.  
  59.    If you want to start Gnus in a different frame, you can use the
  60. command `M-x gnus-other-frame' instead.
  61.  
  62.    If things do not go smoothly at startup, you have to twiddle some
  63. variables.
  64.  
  65. * Menu:
  66.  
  67. * Finding the News::    Choosing a method for getting news.
  68. * The First Time::      What does Gnus do the first time you start it?
  69. * The Server is Down::  How can I read my mail then?
  70. * Slave Gnusae::        You can have more than one Gnus active at a time.
  71. * Fetching a Group::    Starting Gnus just to read a group.
  72. * New Groups::          What is Gnus supposed to do with new groups?
  73. * Startup Files::       Those pesky startup files--`.newsrc'.
  74. * Auto Save::           Recovering from a crash.
  75. * The Active File::     Reading the active file over a slow line Takes Time.
  76. * Changing Servers::    You may want to move from one server to another.
  77. * Startup Variables::   Other variables you might change.
  78.  
  79. 
  80. File: gnus.info,  Node: Finding the News,  Next: The First Time,  Up: Starting Up
  81.  
  82. Finding the News
  83. ================
  84.  
  85.    The `gnus-select-method' variable says where Gnus should look for
  86. news.  This variable should be a list where the first element says
  87. "how" and the second element says "where".  This method is your native
  88. method.  All groups not fetched with this method are foreign groups.
  89.  
  90.    For instance, if the `news.somewhere.edu' NNTP server is where you
  91. want to get your daily dosage of news from, you'd say:
  92.  
  93.      (setq gnus-select-method '(nntp "news.somewhere.edu"))
  94.  
  95.    If you want to read directly from the local spool, say:
  96.  
  97.      (setq gnus-select-method '(nnspool ""))
  98.  
  99.    If you can use a local spool, you probably should, as it will almost
  100. certainly be much faster.
  101.  
  102.    If this variable is not set, Gnus will take a look at the
  103. `NNTPSERVER' environment variable.  If that variable isn't set, Gnus
  104. will see whether `gnus-nntpserver-file' (`/etc/nntpserver' by default)
  105. has any opinions on the matter.  If that fails as well, Gnus will try
  106. to use the machine running Emacs as an NNTP server.  That's a long
  107. shot, though.
  108.  
  109.    If `gnus-nntp-server' is set, this variable will override
  110. `gnus-select-method'.  You should therefore set `gnus-nntp-server' to
  111. `nil', which is what it is by default.
  112.  
  113.    You can also make Gnus prompt you interactively for the name of an
  114. NNTP server.  If you give a non-numerical prefix to `gnus' (i.e., `C-u
  115. M-x gnus'), Gnus will let you choose between the servers in the
  116. `gnus-secondary-servers' list (if any).  You can also just type in the
  117. name of any server you feel like visiting.
  118.  
  119.    However, if you use one NNTP server regularly and are just
  120. interested in a couple of groups from a different server, you would be
  121. better served by using the `B' command in the group buffer.  It will
  122. let you have a look at what groups are available, and you can subscribe
  123. to any of the groups you want to.  This also makes `.newsrc'
  124. maintenance much tidier.  *Note Foreign Groups::.
  125.  
  126.    A slightly different approach to foreign groups is to set the
  127. `gnus-secondary-select-methods' variable.  The select methods listed in
  128. this variable are in many ways just as native as the
  129. `gnus-select-method' server.  They will also be queried for active
  130. files during startup (if that's required), and new newsgroups that
  131. appear on these servers will be subscribed (or not) just as native
  132. groups are.
  133.  
  134.    For instance, if you use the `nnmbox' backend to read your mail, you
  135. would typically set this variable to
  136.  
  137.      (setq gnus-secondary-select-methods '((nnmbox "")))
  138.  
  139. 
  140. File: gnus.info,  Node: The First Time,  Next: The Server is Down,  Prev: Finding the News,  Up: Starting Up
  141.  
  142. The First Time
  143. ==============
  144.  
  145.    If no startup files exist, Gnus will try to determine what groups
  146. should be subscribed by default.
  147.  
  148.    If the variable `gnus-default-subscribed-newsgroups' is set, Gnus
  149. will subscribe you to just those groups in that list, leaving the rest
  150. killed.  Your system administrator should have set this variable to
  151. something useful.
  152.  
  153.    Since she hasn't, Gnus will just subscribe you to a few arbitrarily
  154. picked groups (i.e., `*.newusers').  ("Arbitrary" is defined here as
  155. "whatever Lars thinks you should read".)
  156.  
  157.    You'll also be subscribed to the Gnus documentation group, which
  158. should help you with most common problems.
  159.  
  160.    If `gnus-default-subscribed-newsgroups' is `t', Gnus will just use
  161. the normal functions for handling new groups, and not do anything
  162. special.
  163.  
  164. 
  165. File: gnus.info,  Node: The Server is Down,  Next: Slave Gnusae,  Prev: The First Time,  Up: Starting Up
  166.  
  167. The Server is Down
  168. ==================
  169.  
  170.    If the default server is down, Gnus will understandably have some
  171. problems starting.  However, if you have some mail groups in addition to
  172. the news groups, you may want to start Gnus anyway.
  173.  
  174.    Gnus, being the trusting sort of program, will ask whether to proceed
  175. without a native select method if that server can't be contacted.  This
  176. will happen whether the server doesn't actually exist (i.e., you have
  177. given the wrong address) or the server has just momentarily taken ill
  178. for some reason or other.  If you decide to continue and have no foreign
  179. groups, you'll find it difficult to actually do anything in the group
  180. buffer.  But, hey, that's your problem.  Blllrph!
  181.  
  182.    If you know that the server is definitely down, or you just want to
  183. read your mail without bothering with the server at all, you can use the
  184. `gnus-no-server' command to start Gnus.  That might come in handy if
  185. you're in a hurry as well.  This command will not attempt to contact
  186. your primary server--instead, it will just activate all groups on level
  187. 1 and 2.  (You should preferably keep no native groups on those two
  188. levels.)
  189.  
  190. 
  191. File: gnus.info,  Node: Slave Gnusae,  Next: Fetching a Group,  Prev: The Server is Down,  Up: Starting Up
  192.  
  193. Slave Gnusae
  194. ============
  195.  
  196.    You might want to run more than one Emacs with more than one Gnus at
  197. the same time.  If you are using different `.newsrc' files (e.g., if you
  198. are using the two different Gnusae to read from two different servers),
  199. that is no problem whatsoever.  You just do it.
  200.  
  201.    The problem appears when you want to run two Gnusae that use the same
  202. `.newsrc' file.
  203.  
  204.    To work around that problem some, we here at the Think-Tank at the
  205. Gnus Towers have come up with a new concept: "Masters" and "slaves".
  206. (We have applied for a patent on this concept, and have taken out a
  207. copyright on those words.  If you wish to use those words in
  208. conjunction with each other, you have to send $1 per usage instance to
  209. me.  Usage of the patent ("Master/Slave Relationships In Computer
  210. Applications") will be much more expensive, of course.)
  211.  
  212.    Anyways, you start one Gnus up the normal way with `M-x gnus' (or
  213. however you do it).  Each subsequent slave Gnusae should be started with
  214. `M-x gnus-slave'.  These slaves won't save normal `.newsrc' files, but
  215. instead save "slave files" that contain information only on what groups
  216. have been read in the slave session.  When a master Gnus starts, it
  217. will read (and delete) these slave files, incorporating all information
  218. from them.  (The slave files will be read in the sequence they were
  219. created, so the latest changes will have precedence.)
  220.  
  221.    Information from the slave files has, of course, precedence over the
  222. information in the normal (i.e., master) `.newsrc' file.
  223.  
  224. 
  225. File: gnus.info,  Node: Fetching a Group,  Next: New Groups,  Prev: Slave Gnusae,  Up: Starting Up
  226.  
  227. Fetching a Group
  228. ================
  229.  
  230.    It is sometimes convenient to be able to just say "I want to read
  231. this group and I don't care whether Gnus has been started or not".
  232. This is perhaps more useful for people who write code than for users,
  233. but the command `gnus-fetch-group' provides this functionality in any
  234. case.  It takes the group name as a parameter.
  235.  
  236. 
  237. File: gnus.info,  Node: New Groups,  Next: Startup Files,  Prev: Fetching a Group,  Up: Starting Up
  238.  
  239. New Groups
  240. ==========
  241.  
  242.    If you are satisfied that you really never want to see any new
  243. groups, you can set `gnus-check-new-newsgroups' to `nil'.  This will
  244. also save you some time at startup.  Even if this variable is `nil',
  245. you can always subscribe to the new groups just by pressing `U' in the
  246. group buffer (*note Group Maintenance::.).  This variable is
  247. `ask-server' by default.  If you set this variable to `always', then
  248. Gnus will query the backends for new groups even when you do the `g'
  249. command (*note Scanning New Messages::.).
  250.  
  251. * Menu:
  252.  
  253. * Checking New Groups::      Determining what groups are new.
  254. * Subscription Methods::     What Gnus should do with new groups.
  255. * Filtering New Groups::     Making Gnus ignore certain new groups.
  256.  
  257. 
  258. File: gnus.info,  Node: Checking New Groups,  Next: Subscription Methods,  Up: New Groups
  259.  
  260. Checking New Groups
  261. -------------------
  262.  
  263.    Gnus normally determines whether a group is new or not by comparing
  264. the list of groups from the active file(s) with the lists of subscribed
  265. and dead groups.  This isn't a particularly fast method.  If
  266. `gnus-check-new-newsgroups' is `ask-server', Gnus will ask the server
  267. for new groups since the last time.  This is both faster and cheaper.
  268. This also means that you can get rid of the list of killed groups
  269. altogether, so you may set `gnus-save-killed-list' to `nil', which will
  270. save time both at startup, at exit, and all over.  Saves disk space,
  271. too.  Why isn't this the default, then?  Unfortunately, not all servers
  272. support this command.
  273.  
  274.    I bet I know what you're thinking now: How do I find out whether my
  275. server supports `ask-server'?  No?  Good, because I don't have a
  276. fail-safe answer.  I would suggest just setting this variable to
  277. `ask-server' and see whether any new groups appear within the next few
  278. days.  If any do, then it works.  If none do, then it doesn't work.  I
  279. could write a function to make Gnus guess whether the server supports
  280. `ask-server', but it would just be a guess.  So I won't.  You could
  281. `telnet' to the server and say `HELP' and see whether it lists
  282. `NEWGROUPS' among the commands it understands.  If it does, then it
  283. might work.  (But there are servers that lists `NEWGROUPS' without
  284. supporting the function properly.)
  285.  
  286.    This variable can also be a list of select methods.  If so, Gnus will
  287. issue an `ask-server' command to each of the select methods, and
  288. subscribe them (or not) using the normal methods.  This might be handy
  289. if you are monitoring a few servers for new groups.  A side effect is
  290. that startup will take much longer, so you can meditate while waiting.
  291. Use the mantra "dingnusdingnusdingnus" to achieve permanent bliss.
  292.  
  293. 
  294. File: gnus.info,  Node: Subscription Methods,  Next: Filtering New Groups,  Prev: Checking New Groups,  Up: New Groups
  295.  
  296. Subscription Methods
  297. --------------------
  298.  
  299.    What Gnus does when it encounters a new group is determined by the
  300. `gnus-subscribe-newsgroup-method' variable.
  301.  
  302.    This variable should contain a function.  This function will be
  303. called with the name of the new group as the only parameter.
  304.  
  305.    Some handy pre-fab functions are:
  306.  
  307. `gnus-subscribe-zombies'
  308.      Make all new groups zombies.  This is the default.  You can browse
  309.      the zombies later (with `A z') and either kill them all off
  310.      properly (with `S z'), or subscribe to them (with `u').
  311.  
  312. `gnus-subscribe-randomly'
  313.      Subscribe all new groups randomly.
  314.  
  315. `gnus-subscribe-alphabetically'
  316.      Subscribe all new groups alphabetically.
  317.  
  318. `gnus-subscribe-hierarchically'
  319.      Subscribe all new groups hierarchically.  The difference between
  320.      this function and `gnus-subscribe-alphabetically' is slight.
  321.      `gnus-subscribe-alphabetically' will subscribe new groups in a
  322.      strictly alphabetical fashion, while this function will enter
  323.      groups into it's hierarchy.  So if you want to have the `rec'
  324.      hierarchy before the `comp' hierarchy, this function will not mess
  325.      that configuration up.  Or something like that.
  326.  
  327. `gnus-subscribe-interactively'
  328.      Subscribe new groups interactively.  This means that Gnus will ask
  329.      you about *all* new groups.
  330.  
  331. `gnus-subscribe-killed'
  332.      Kill all new groups.
  333.  
  334.    A closely related variable is
  335. `gnus-subscribe-hierarchical-interactive'.  (That's quite a mouthful.)
  336. If this variable is non-`nil', Gnus will ask you in a hierarchical
  337. fashion whether to subscribe to new groups or not.  Gnus will ask you
  338. for each sub-hierarchy whether you want to descend the hierarchy or not.
  339.  
  340.    One common mistake is to set the variable a few paragraphs above
  341. (`gnus-subscribe-newsgroup-method') to
  342. `gnus-subscribe-hierarchical-interactive'.  This is an error.  This
  343. will not work.  This is ga-ga.  So don't do it.
  344.  
  345. 
  346. File: gnus.info,  Node: Filtering New Groups,  Prev: Subscription Methods,  Up: New Groups
  347.  
  348. Filtering New Groups
  349. --------------------
  350.  
  351.    A nice and portable way to control which new newsgroups should be
  352. subscribed (or ignored) is to put an "options" line at the start of the
  353. `.newsrc' file.  Here's an example:
  354.  
  355.      options -n !alt.all !rec.all sci.all
  356.  
  357.    This line obviously belongs to a serious-minded intellectual
  358. scientific person (or she may just be plain old boring), because it
  359. says that all groups that have names beginning with `alt' and `rec'
  360. should be ignored, and all groups with names beginning with `sci' should
  361. be subscribed.  Gnus will not use the normal subscription method for
  362. subscribing these groups.  `gnus-subscribe-options-newsgroup-method' is
  363. used instead.  This variable defaults to
  364. `gnus-subscribe-alphabetically'.
  365.  
  366.    If you don't want to mess with your `.newsrc' file, you can just set
  367. the two variables `gnus-options-subscribe' and
  368. `gnus-options-not-subscribe'.  These two variables do exactly the same
  369. as the `.newsrc' `options -n' trick.  Both are regexps, and if the new
  370. group matches the former, it will be unconditionally subscribed, and if
  371. it matches the latter, it will be ignored.
  372.  
  373.    Yet another variable that meddles here is
  374. `gnus-auto-subscribed-groups'.  It works exactly like
  375. `gnus-options-subscribe', and is therefore really superfluous, but I
  376. thought it would be nice to have two of these.  This variable is more
  377. meant for setting some ground rules, while the other variable is used
  378. more for user fiddling.  By default this variable makes all new groups
  379. that come from mail backends (`nnml', `nnbabyl', `nnfolder', `nnmbox',
  380. and `nnmh') subscribed.  If you don't like that, just set this variable
  381. to `nil'.
  382.  
  383.    New groups that match this regexp are subscribed using
  384. `gnus-subscribe-options-newsgroup-method'.
  385.  
  386. 
  387. File: gnus.info,  Node: Changing Servers,  Next: Startup Variables,  Prev: The Active File,  Up: Starting Up
  388.  
  389. Changing Servers
  390. ================
  391.  
  392.    Sometimes it is necessary to move from one NNTP server to another.
  393. This happens very rarely, but perhaps you change jobs, or one server is
  394. very flaky and you want to use another.
  395.  
  396.    Changing the server is pretty easy, right?  You just change
  397. `gnus-select-method' to point to the new server?
  398.  
  399.    *Wrong!*
  400.  
  401.    Article numbers are not (in any way) kept synchronized between
  402. different NNTP servers, and the only way Gnus keeps track of what
  403. articles you have read is by keeping track of article numbers.  So when
  404. you change `gnus-select-method', your `.newsrc' file becomes worthless.
  405.  
  406.    Gnus provides a few functions to attempt to translate a `.newsrc'
  407. file from one server to another.  They all have one thing in
  408. common--they take a looong time to run.  You don't want to use these
  409. functions more than absolutely necessary.
  410.  
  411.    If you have access to both servers, Gnus can request the headers for
  412. all the articles you have read and compare `Message-ID's and map the
  413. article numbers of the read articles and article marks.  The `M-x
  414. gnus-change-server' command will do this for all your native groups.  It
  415. will prompt for the method you want to move to.
  416.  
  417.    You can also move individual groups with the `M-x
  418. gnus-group-move-group-to-server' command.  This is useful if you want to
  419. move a (foreign) group from one server to another.
  420.  
  421.    If you don't have access to both the old and new server, all your
  422. marks and read ranges have become worthless.  You can use the `M-x
  423. gnus-group-clear-data-on-native-groups' command to clear out all data
  424. that you have on your native groups.  Use with caution.
  425.  
  426. 
  427. File: gnus.info,  Node: Startup Files,  Next: Auto Save,  Prev: New Groups,  Up: Starting Up
  428.  
  429. Startup Files
  430. =============
  431.  
  432.    Now, you all know about the `.newsrc' file.  All subscription
  433. information is traditionally stored in this file.
  434.  
  435.    Things got a bit more complicated with GNUS.  In addition to keeping
  436. the `.newsrc' file updated, it also used a file called `.newsrc.el' for
  437. storing all the information that didn't fit into the `.newsrc' file.
  438. (Actually, it also duplicated everything in the `.newsrc' file.)  GNUS
  439. would read whichever one of these files was the most recently saved,
  440. which enabled people to swap between GNUS and other newsreaders.
  441.  
  442.    That was kinda silly, so Gnus went one better: In addition to the
  443. `.newsrc' and `.newsrc.el' files, Gnus also has a file called
  444. `.newsrc.eld'.  It will read whichever of these files that are most
  445. recent, but it will never write a `.newsrc.el' file.
  446.  
  447.    You can turn off writing the `.newsrc' file by setting
  448. `gnus-save-newsrc-file' to `nil', which means you can delete the file
  449. and save some space, as well as making exit from Gnus faster.  However,
  450. this will make it impossible to use other newsreaders than Gnus.  But
  451. hey, who would want to, right?
  452.  
  453.    If `gnus-save-killed-list' (default `t') is `nil', Gnus will not
  454. save the list of killed groups to the startup file.  This will save
  455. both time (when starting and quitting) and space (on disk).  It will
  456. also mean that Gnus has no record of what groups are new or old, so the
  457. automatic new groups subscription methods become meaningless.  You
  458. should always set `gnus-check-new-newsgroups' to `nil' or `ask-server'
  459. if you set this variable to `nil' (*note New Groups::.).  This variable
  460. can also be a regular expression.  If that's the case, remove all
  461. groups that do not match this regexp before saving.  This can be useful
  462. in certain obscure situations that involve several servers where not
  463. all servers support `ask-server'.
  464.  
  465.    The `gnus-startup-file' variable says where the startup files are.
  466. The default value is `~/.newsrc', with the Gnus (El Dingo) startup file
  467. being whatever that one is, with a `.eld' appended.
  468.  
  469.    `gnus-save-newsrc-hook' is called before saving any of the newsrc
  470. files, while `gnus-save-quick-newsrc-hook' is called just before saving
  471. the `.newsrc.eld' file, and `gnus-save-standard-newsrc-hook' is called
  472. just before saving the `.newsrc' file.  The latter two are commonly
  473. used to turn version control on or off.  Version control is on by
  474. default when saving the startup files.  If you want to turn backup
  475. creation off, say something like:
  476.  
  477.      (defun turn-off-backup ()
  478.        (set (make-local-variable 'backup-inhibited) t))
  479.      
  480.      (add-hook 'gnus-save-quick-newsrc-hook 'turn-off-backup)
  481.      (add-hook 'gnus-save-standard-newsrc-hook 'turn-off-backup)
  482.  
  483.    When Gnus starts, it will read the `gnus-site-init-file'
  484. (`.../site-lisp/gnus' by default) and `gnus-init-file' (`~/.gnus' by
  485. default) files.  These are normal Emacs Lisp files and can be used to
  486. avoid cluttering your `~/.emacs' and `site-init' files with Gnus stuff.
  487. Gnus will also check for files with the same names as these, but with
  488. `.elc' and `.el' suffixes.  In other words, if you have set
  489. `gnus-init-file' to `~/.gnus', it will look for `~/.gnus.elc',
  490. `~/.gnus.el', and finally `~/.gnus' (in this order).
  491.  
  492. 
  493. File: gnus.info,  Node: Auto Save,  Next: The Active File,  Prev: Startup Files,  Up: Starting Up
  494.  
  495. Auto Save
  496. =========
  497.  
  498.    Whenever you do something that changes the Gnus data (reading
  499. articles, catching up, killing/subscribing groups), the change is added
  500. to a special "dribble buffer".  This buffer is auto-saved the normal
  501. Emacs way.  If your Emacs should crash before you have saved the
  502. `.newsrc' files, all changes you have made can be recovered from this
  503. file.
  504.  
  505.    If Gnus detects this file at startup, it will ask the user whether to
  506. read it.  The auto save file is deleted whenever the real startup file
  507. is saved.
  508.  
  509.    If `gnus-use-dribble-file' is `nil', Gnus won't create and maintain
  510. a dribble buffer.  The default is `t'.
  511.  
  512.    Gnus will put the dribble file(s) in `gnus-dribble-directory'.  If
  513. this variable is `nil', which it is by default, Gnus will dribble into
  514. the directory where the `.newsrc' file is located.  (This is normally
  515. the user's home directory.)  The dribble file will get the same file
  516. permissions as the `.newsrc' file.
  517.  
  518. 
  519. File: gnus.info,  Node: The Active File,  Next: Changing Servers,  Prev: Auto Save,  Up: Starting Up
  520.  
  521. The Active File
  522. ===============
  523.  
  524.    When Gnus starts, or indeed whenever it tries to determine whether
  525. new articles have arrived, it reads the active file.  This is a very
  526. large file that lists all the active groups and articles on the server.
  527.  
  528.    Before examining the active file, Gnus deletes all lines that match
  529. the regexp `gnus-ignored-newsgroups'.  This is done primarily to reject
  530. any groups with bogus names, but you can use this variable to make Gnus
  531. ignore hierarchies you aren't ever interested in.  However, this is not
  532. recommended.  In fact, it's highly discouraged.  Instead, *note New
  533. Groups::. for an overview of other variables that can be used instead.
  534.  
  535.    The active file can be rather Huge, so if you have a slow network,
  536. you can set `gnus-read-active-file' to `nil' to prevent Gnus from
  537. reading the active file.  This variable is `some' by default.
  538.  
  539.    Gnus will try to make do by getting information just on the groups
  540. that you actually subscribe to.
  541.  
  542.    Note that if you subscribe to lots and lots of groups, setting this
  543. variable to `nil' will probably make Gnus slower, not faster.  At
  544. present, having this variable `nil' will slow Gnus down considerably,
  545. unless you read news over a 2400 baud modem.
  546.  
  547.    This variable can also have the value `some'.  Gnus will then
  548. attempt to read active info only on the subscribed groups.  On some
  549. servers this is quite fast (on sparkling, brand new INN servers that
  550. support the `LIST ACTIVE group' command), on others this isn't fast at
  551. all.  In any case, `some' should be faster than `nil', and is certainly
  552. faster than `t' over slow lines.
  553.  
  554.    If this variable is `nil', Gnus will ask for group info in total
  555. lock-step, which isn't very fast.  If it is `some' and you use an NNTP
  556. server, Gnus will pump out commands as fast as it can, and read all the
  557. replies in one swoop.  This will normally result in better performance,
  558. but if the server does not support the aforementioned `LIST ACTIVE
  559. group' command, this isn't very nice to the server.
  560.  
  561.    In any case, if you use `some' or `nil', you should definitely kill
  562. all groups that you aren't interested in to speed things up.
  563.  
  564.    Note that this variable also affects active file retrieval from
  565. secondary select methods.
  566.  
  567. 
  568. File: gnus.info,  Node: Startup Variables,  Prev: Changing Servers,  Up: Starting Up
  569.  
  570. Startup Variables
  571. =================
  572.  
  573. `gnus-load-hook'
  574.      A hook run while Gnus is being loaded.  Note that this hook will
  575.      normally be run just once in each Emacs session, no matter how many
  576.      times you start Gnus.
  577.  
  578. `gnus-startup-hook'
  579.      A hook run after starting up Gnus successfully.
  580.  
  581. `gnus-started-hook'
  582.      A hook run as the very last thing after starting up Gnus
  583.      successfully.
  584.  
  585. `gnus-check-bogus-newsgroups'
  586.      If non-`nil', Gnus will check for and delete all bogus groups at
  587.      startup.  A "bogus group" is a group that you have in your
  588.      `.newsrc' file, but doesn't exist on the news server.  Checking for
  589.      bogus groups can take quite a while, so to save time and resources
  590.      it's best to leave this option off, and do the checking for bogus
  591.      groups once in a while from the group buffer instead (*note Group
  592.      Maintenance::.).
  593.  
  594. `gnus-inhibit-startup-message'
  595.      If non-`nil', the startup message won't be displayed.  That way,
  596.      your boss might not notice as easily that you are reading news
  597.      instead of doing your job.  Note that this variable is used before
  598.      `.gnus.el' is loaded, so it should be set in `.emacs' instead.
  599.  
  600. `gnus-no-groups-message'
  601.      Message displayed by Gnus when no groups are available.
  602.  
  603. `gnus-play-startup-jingle'
  604.      If non-`nil', play the Gnus jingle at startup.
  605.  
  606. `gnus-startup-jingle'
  607.      Jingle to be played if the above variable is non-`nil'.  The
  608.      default is `Tuxedomoon.Jingle4.au'.
  609.  
  610. 
  611. File: gnus.info,  Node: The Group Buffer,  Next: The Summary Buffer,  Prev: Starting Up,  Up: Top
  612.  
  613. The Group Buffer
  614. ****************
  615.  
  616.    The "group buffer" lists all (or parts) of the available groups.  It
  617. is the first buffer shown when Gnus starts, and will never be killed as
  618. long as Gnus is active.
  619.  
  620. * Menu:
  621.  
  622. * Group Buffer Format::    Information listed and how you can change it.
  623. * Group Maneuvering::      Commands for moving in the group buffer.
  624. * Selecting a Group::      Actually reading news.
  625. * Group Data::             Changing the info for a group.
  626. * Subscription Commands::  Unsubscribing, killing, subscribing.
  627. * Group Levels::           Levels? What are those, then?
  628. * Group Score::            A mechanism for finding out what groups you like.
  629. * Marking Groups::         You can mark groups for later processing.
  630. * Foreign Groups::         Creating and editing groups.
  631. * Group Parameters::       Each group may have different parameters set.
  632. * Listing Groups::         Gnus can list various subsets of the groups.
  633. * Sorting Groups::         Re-arrange the group order.
  634. * Group Maintenance::      Maintaining a tidy `.newsrc' file.
  635. * Browse Foreign Server::  You can browse a server.  See what it has to offer.
  636. * Exiting Gnus::           Stop reading news and get some work done.
  637. * Group Topics::           A folding group mode divided into topics.
  638. * Misc Group Stuff::       Other stuff that you can to do.
  639.  
  640. 
  641. File: gnus.info,  Node: Group Buffer Format,  Next: Group Maneuvering,  Up: The Group Buffer
  642.  
  643. Group Buffer Format
  644. ===================
  645.  
  646. * Menu:
  647.  
  648. * Group Line Specification::       Deciding how the group buffer is to look.
  649. * Group Modeline Specification::   The group buffer modeline.
  650. * Group Highlighting::             Having nice colors in the group buffer.
  651.  
  652. 
  653. File: gnus.info,  Node: Group Line Specification,  Next: Group Modeline Specification,  Up: Group Buffer Format
  654.  
  655. Group Line Specification
  656. ------------------------
  657.  
  658.    The default format of the group buffer is nice and dull, but you can
  659. make it as exciting and ugly as you feel like.
  660.  
  661.    Here's a couple of example group lines:
  662.  
  663.           25: news.announce.newusers
  664.       *    0: alt.fan.andrea-dworkin
  665.  
  666.    Quite simple, huh?
  667.  
  668.    You can see that there are 25 unread articles in
  669. `news.announce.newusers'.  There are no unread articles, but some
  670. ticked articles, in `alt.fan.andrea-dworkin' (see that little asterisk
  671. at the beginning of the line?).
  672.  
  673.    You can change that format to whatever you want by fiddling with the
  674. `gnus-group-line-format' variable.  This variable works along the lines
  675. of a `format' specification, which is pretty much the same as a
  676. `printf' specifications, for those of you who use (feh!) C.  *Note
  677. Formatting Variables::.
  678.  
  679.    `%M%S%5y: %(%g%)\n' is the value that produced those lines above.
  680.  
  681.    There should always be a colon on the line; the cursor always moves
  682. to the colon after performing an operation.  Nothing else is
  683. required--not even the group name.  All displayed text is just window
  684. dressing, and is never examined by Gnus.  Gnus stores all real
  685. information it needs using text properties.
  686.  
  687.    (Note that if you make a really strange, wonderful, spreadsheet-like
  688. layout, everybody will believe you are hard at work with the accounting
  689. instead of wasting time reading news.)
  690.  
  691.    Here's a list of all available format characters:
  692.  
  693. `M'
  694.      An asterisk if the group only has marked articles.
  695.  
  696. `S'
  697.      Whether the group is subscribed.
  698.  
  699. `L'
  700.      Level of subscribedness.
  701.  
  702. `N'
  703.      Number of unread articles.
  704.  
  705. `I'
  706.      Number of dormant articles.
  707.  
  708. `T'
  709.      Number of ticked articles.
  710.  
  711. `R'
  712.      Number of read articles.
  713.  
  714. `t'
  715.      Estimated total number of articles.  (This is really MAX-NUMBER
  716.      minus MIN-NUMBER plus 1.)
  717.  
  718. `y'
  719.      Number of unread, unticked, non-dormant articles.
  720.  
  721. `i'
  722.      Number of ticked and dormant articles.
  723.  
  724. `g'
  725.      Full group name.
  726.  
  727. `G'
  728.      Group name.
  729.  
  730. `D'
  731.      Newsgroup description.
  732.  
  733. `o'
  734.      `m' if moderated.
  735.  
  736. `O'
  737.      `(m)' if moderated.
  738.  
  739. `s'
  740.      Select method.
  741.  
  742. `n'
  743.      Select from where.
  744.  
  745. `z'
  746.      A string that looks like `<%s:%n>' if a foreign select method is
  747.      used.
  748.  
  749. `P'
  750.      Indentation based on the level of the topic (*note Group
  751.      Topics::.).
  752.  
  753. `c'
  754.      Short (collapsed) group name.  The `gnus-group-uncollapsed-levels'
  755.      variable says how many levels to leave at the end of the group
  756.      name.  The default is 1--this will mean that group names like
  757.      `gnu.emacs.gnus' will be shortened to `g.emacs.gnus'.
  758.  
  759. `m'
  760.      `%' (`gnus-new-mail-mark') if there has arrived new mail to the
  761.      group lately.
  762.  
  763. `d'
  764.      A string that says when you last read the group (*note Group
  765.      Timestamp::.).
  766.  
  767. `u'
  768.      User defined specifier.  The next character in the format string
  769.      should be a letter.  Gnus will call the function
  770.      `gnus-user-format-function-'`X', where `X' is the letter following
  771.      `%u'.  The function will be passed a single dummy parameter as
  772.      argument.  The function should return a string, which will be
  773.      inserted into the buffer just like information from any other
  774.      specifier.
  775.  
  776.    All the "number-of" specs will be filled with an asterisk (`*') if
  777. no info is available--for instance, if it is a non-activated foreign
  778. group, or a bogus native group.
  779.  
  780. 
  781. File: gnus.info,  Node: Group Modeline Specification,  Next: Group Highlighting,  Prev: Group Line Specification,  Up: Group Buffer Format
  782.  
  783. Group Modeline Specification
  784. ----------------------------
  785.  
  786.    The mode line can be changed by setting
  787. `gnus-group-mode-line-format' (*note Formatting Variables::.).  It
  788. doesn't understand that many format specifiers:
  789.  
  790. `S'
  791.      The native news server.
  792.  
  793. `M'
  794.      The native select method.
  795.  
  796. 
  797. File: gnus.info,  Node: Group Highlighting,  Prev: Group Modeline Specification,  Up: Group Buffer Format
  798.  
  799. Group Highlighting
  800. ------------------
  801.  
  802.    Highlighting in the group buffer is controlled by the
  803. `gnus-group-highlight' variable.  This is an alist with elements that
  804. look like (FORM . FACE).  If FORM evaluates to something non-`nil', the
  805. FACE will be used on the line.
  806.  
  807.    Here's an example value for this variable that might look nice if the
  808. background is dark:
  809.  
  810.      (setq gnus-group-highlight
  811.            `(((> unread 200) .
  812.               ,(custom-face-lookup "Red" nil nil t nil nil))
  813.              ((and (< level 3) (zerop unread)) .
  814.               ,(custom-face-lookup "SeaGreen" nil nil t nil nil))
  815.              ((< level 3) .
  816.               ,(custom-face-lookup "SpringGreen" nil nil t nil nil))
  817.              ((zerop unread) .
  818.               ,(custom-face-lookup "SteelBlue" nil nil t nil nil))
  819.              (t .
  820.               ,(custom-face-lookup "SkyBlue" nil nil t nil nil))))
  821.  
  822.    Variables that are dynamically bound when the forms are evaluated
  823. include:
  824.  
  825. `group'
  826.      The group name.
  827.  
  828. `unread'
  829.      The number of unread articles in the group.
  830.  
  831. `method'
  832.      The select method.
  833.  
  834. `mailp'
  835.      Whether the group is a mail group.
  836.  
  837. `level'
  838.      The level of the group.
  839.  
  840. `score'
  841.      The score of the group.
  842.  
  843. `ticked'
  844.      The number of ticked articles in the group.
  845.  
  846. `total'
  847.      The total number of articles in the group.  Or rather, MAX-NUMBER
  848.      minus MIN-NUMBER plus one.
  849.  
  850. `topic'
  851.      When using the topic minor mode, this variable is bound to the
  852.      current topic being inserted.
  853.  
  854.    When the forms are `eval'ed, point is at the beginning of the line
  855. of the group in question, so you can use many of the normal Gnus
  856. functions for snarfing info on the group.
  857.  
  858.    `gnus-group-update-hook' is called when a group line is changed.  It
  859. will not be called when `gnus-visual' is `nil'.  This hook calls
  860. `gnus-group-highlight-line' by default.
  861.  
  862. 
  863. File: gnus.info,  Node: Group Maneuvering,  Next: Selecting a Group,  Prev: Group Buffer Format,  Up: The Group Buffer
  864.  
  865. Group Maneuvering
  866. =================
  867.  
  868.    All movement commands understand the numeric prefix and will behave
  869. as expected, hopefully.
  870.  
  871. `n'
  872.      Go to the next group that has unread articles
  873.      (`gnus-group-next-unread-group').
  874.  
  875. `p'
  876. `DEL'
  877.      Go to the previous group that has unread articles
  878.      (`gnus-group-prev-unread-group').
  879.  
  880. `N'
  881.      Go to the next group (`gnus-group-next-group').
  882.  
  883. `P'
  884.      Go to the previous group (`gnus-group-prev-group').
  885.  
  886. `M-p'
  887.      Go to the next unread group on the same (or lower) level
  888.      (`gnus-group-next-unread-group-same-level').
  889.  
  890. `M-n'
  891.      Go to the previous unread group on the same (or lower) level
  892.      (`gnus-group-prev-unread-group-same-level').
  893.  
  894.    Three commands for jumping to groups:
  895.  
  896. `j'
  897.      Jump to a group (and make it visible if it isn't already)
  898.      (`gnus-group-jump-to-group').  Killed groups can be jumped to, just
  899.      like living groups.
  900.  
  901. `,'
  902.      Jump to the unread group with the lowest level
  903.      (`gnus-group-best-unread-group').
  904.  
  905. `.'
  906.      Jump to the first group with unread articles
  907.      (`gnus-group-first-unread-group').
  908.  
  909.    If `gnus-group-goto-unread' is `nil', all the movement commands will
  910. move to the next group, not the next unread group.  Even the commands
  911. that say they move to the next unread group.  The default is `t'.
  912.  
  913. 
  914. File: gnus.info,  Node: Selecting a Group,  Next: Group Data,  Prev: Group Maneuvering,  Up: The Group Buffer
  915.  
  916. Selecting a Group
  917. =================
  918.  
  919. `SPACE'
  920.      Select the current group, switch to the summary buffer and display
  921.      the first unread article (`gnus-group-read-group').  If there are
  922.      no unread articles in the group, or if you give a non-numerical
  923.      prefix to this command, Gnus will offer to fetch all the old
  924.      articles in this group from the server.  If you give a numerical
  925.      prefix N, N determines the number of articles Gnus will fetch.  If
  926.      N is positive, Gnus fetches the N newest articles, if N is
  927.      negative, Gnus fetches the ABS(N) oldest articles.
  928.  
  929. `RET'
  930.      Select the current group and switch to the summary buffer
  931.      (`gnus-group-select-group').  Takes the same arguments as
  932.      `gnus-group-read-group'--the only difference is that this command
  933.      does not display the first unread article automatically upon group
  934.      entry.
  935.  
  936. `M-RET'
  937.      This does the same as the command above, but tries to do it with
  938.      the minimum amount of fuzz (`gnus-group-quick-select-group').  No
  939.      scoring/killing will be performed, there will be no highlights and
  940.      no expunging.  This might be useful if you're in a real hurry and
  941.      have to enter some humongous group.  If you give a 0 prefix to
  942.      this command (i.e., `0 M-RET'), Gnus won't even generate the
  943.      summary buffer.  This might be useful if you want to toggle
  944.      threading before entering the group.
  945.  
  946. `M-SPACE'
  947.      This is yet one more command that does the same as the `RET'
  948.      command, but this one does it without expunging and hiding dormants
  949.      (`gnus-group-visible-select-group').
  950.  
  951. `M-C-RET'
  952.      Finally, this command selects the current group ephemerally without
  953.      doing any processing of its contents
  954.      (`gnus-group-select-group-ephemerally').  Even threading has been
  955.      turned off.  Everything you do in the group after selecting it in
  956.      this manner will have no permanent effects.
  957.  
  958.    The `gnus-large-newsgroup' variable says what Gnus should consider
  959. to be a big group.  This is 200 by default.  If the group has more
  960. (unread and/or ticked) articles than this, Gnus will query the user
  961. before entering the group.  The user can then specify how many articles
  962. should be fetched from the server.  If the user specifies a negative
  963. number (`-n'), the `n' oldest articles will be fetched.  If it is
  964. positive, the `n' articles that have arrived most recently will be
  965. fetched.
  966.  
  967.    `gnus-auto-select-first' control whether any articles are selected
  968. automatically when entering a group with the `SPACE' command.
  969.  
  970. `nil'
  971.      Don't select any articles when entering the group.  Just display
  972.      the full summary buffer.
  973.  
  974. `t'
  975.      Select the first unread article when entering the group.
  976.  
  977. `best'
  978.      Select the most high-scored article in the group when entering the
  979.      group.
  980.  
  981.    If you want to prevent automatic selection in some group (say, in a
  982. binary group with Huge articles) you can set this variable to `nil' in
  983. `gnus-select-group-hook', which is called when a group is selected.
  984.  
  985. 
  986. File: gnus.info,  Node: Subscription Commands,  Next: Group Levels,  Prev: Group Data,  Up: The Group Buffer
  987.  
  988. Subscription Commands
  989. =====================
  990.  
  991. `S t'
  992. `u'
  993.      Toggle subscription to the current group
  994.      (`gnus-group-unsubscribe-current-group').
  995.  
  996. `S s'
  997. `U'
  998.      Prompt for a group to subscribe, and then subscribe it.  If it was
  999.      subscribed already, unsubscribe it instead
  1000.      (`gnus-group-unsubscribe-group').
  1001.  
  1002. `S k'
  1003. `C-k'
  1004.      Kill the current group (`gnus-group-kill-group').
  1005.  
  1006. `S y'
  1007. `C-y'
  1008.      Yank the last killed group (`gnus-group-yank-group').
  1009.  
  1010. `C-x C-t'
  1011.      Transpose two groups (`gnus-group-transpose-groups').  This isn't
  1012.      really a subscription command, but you can use it instead of a
  1013.      kill-and-yank sequence sometimes.
  1014.  
  1015. `S w'
  1016. `C-w'
  1017.      Kill all groups in the region (`gnus-group-kill-region').
  1018.  
  1019. `S z'
  1020.      Kill all zombie groups (`gnus-group-kill-all-zombies').
  1021.  
  1022. `S C-k'
  1023.      Kill all groups on a certain level (`gnus-group-kill-level').
  1024.      These groups can't be yanked back after killing, so this command
  1025.      should be used with some caution.  The only time where this
  1026.      command comes in really handy is when you have a `.newsrc' with
  1027.      lots of unsubscribed groups that you want to get rid off.  `S C-k'
  1028.      on level 7 will kill off all unsubscribed groups that do not have
  1029.      message numbers in the `.newsrc' file.
  1030.  
  1031.    Also *note Group Levels::..
  1032.  
  1033. 
  1034. File: gnus.info,  Node: Group Data,  Next: Subscription Commands,  Prev: Selecting a Group,  Up: The Group Buffer
  1035.  
  1036. Group Data
  1037. ==========
  1038.  
  1039. `c'
  1040.      Mark all unticked articles in this group as read
  1041.      (`gnus-group-catchup-current').  `gnus-group-catchup-group-hook'
  1042.      is called when catching up a group from the group buffer.
  1043.  
  1044. `C'
  1045.      Mark all articles in this group, even the ticked ones, as read
  1046.      (`gnus-group-catchup-current-all').
  1047.  
  1048. `M-c'
  1049.      Clear the data from the current group--nix out marks and the list
  1050.      of read articles (`gnus-group-clear-data').
  1051.  
  1052. `M-x gnus-group-clear-data-on-native-groups'
  1053.      If you have switched from one NNTP server to another, all your
  1054.      marks and read ranges have become worthless.  You can use this
  1055.      command to clear out all data that you have on your native groups.
  1056.      Use with caution.
  1057.  
  1058. 
  1059. File: gnus.info,  Node: Group Levels,  Next: Group Score,  Prev: Subscription Commands,  Up: The Group Buffer
  1060.  
  1061. Group Levels
  1062. ============
  1063.  
  1064.    All groups have a level of "subscribedness".  For instance, if a
  1065. group is on level 2, it is more subscribed than a group on level 5.  You
  1066. can ask Gnus to just list groups on a given level or lower (*note
  1067. Listing Groups::.), or to just check for new articles in groups on a
  1068. given level or lower (*note Scanning New Messages::.).
  1069.  
  1070.    Remember:  The higher the level of the group, the less important it
  1071. is.
  1072.  
  1073. `S l'
  1074.      Set the level of the current group.  If a numeric prefix is given,
  1075.      the next N groups will have their levels set.  The user will be
  1076.      prompted for a level.
  1077.  
  1078.    Gnus considers groups from levels 1 to `gnus-level-subscribed'
  1079. (inclusive) (default 5) to be subscribed, `gnus-level-subscribed'
  1080. (exclusive) and `gnus-level-unsubscribed' (inclusive) (default 7) to be
  1081. unsubscribed, `gnus-level-zombie' to be zombies (walking dead) (default
  1082. 8) and `gnus-level-killed' to be killed (completely dead) (default 9).
  1083. Gnus treats subscribed and unsubscribed groups exactly the same, but
  1084. zombie and killed groups have no information on what articles you have
  1085. read, etc, stored.  This distinction between dead and living groups
  1086. isn't done because it is nice or clever, it is done purely for reasons
  1087. of efficiency.
  1088.  
  1089.    It is recommended that you keep all your mail groups (if any) on
  1090. quite low levels (e.g. 1 or 2).
  1091.  
  1092.    If you want to play with the level variables, you should show some
  1093. care.  Set them once, and don't touch them ever again.  Better yet,
  1094. don't touch them at all unless you know exactly what you're doing.
  1095.  
  1096.    Two closely related variables are `gnus-level-default-subscribed'
  1097. (default 3) and `gnus-level-default-unsubscribed' (default 6), which
  1098. are the levels that new groups will be put on if they are
  1099. (un)subscribed.  These two variables should, of course, be inside the
  1100. relevant legal ranges.
  1101.  
  1102.    If `gnus-keep-same-level' is non-`nil', some movement commands will
  1103. only move to groups of the same level (or lower).  In particular, going
  1104. from the last article in one group to the next group will go to the
  1105. next group of the same level (or lower).  This might be handy if you
  1106. want to read the most important groups before you read the rest.
  1107.  
  1108.    All groups with a level less than or equal to
  1109. `gnus-group-default-list-level' will be listed in the group buffer by
  1110. default.
  1111.  
  1112.    If `gnus-group-list-inactive-groups' is non-`nil', non-active groups
  1113. will be listed along with the unread groups.  This variable is `t' by
  1114. default.  If it is `nil', inactive groups won't be listed.
  1115.  
  1116.    If `gnus-group-use-permanent-levels' is non-`nil', once you give a
  1117. level prefix to `g' or `l', all subsequent commands will use this level
  1118. as the "work" level.
  1119.  
  1120.    Gnus will normally just activate groups on level
  1121. `gnus-activate-level' or less.  If you don't want to activate
  1122. unsubscribed groups, for instance, you might set this variable to 5.
  1123. The default is 6.
  1124.  
  1125. 
  1126. File: gnus.info,  Node: Group Score,  Next: Marking Groups,  Prev: Group Levels,  Up: The Group Buffer
  1127.  
  1128. Group Score
  1129. ===========
  1130.  
  1131.    You would normally keep important groups on high levels, but that
  1132. scheme is somewhat restrictive.  Don't you wish you could have Gnus
  1133. sort the group buffer according to how often you read groups, perhaps?
  1134. Within reason?
  1135.  
  1136.    This is what "group score" is for.  You can assign a score to each
  1137. group.  You can then sort the group buffer based on this score.
  1138. Alternatively, you can sort on score and then level.  (Taken together,
  1139. the level and the score is called the "rank" of the group.  A group
  1140. that is on level 4 and has a score of 1 has a higher rank than a group
  1141. on level 5 that has a score of 300.  (The level is the most significant
  1142. part and the score is the least significant part.))
  1143.  
  1144.    If you want groups you read often to get higher scores than groups
  1145. you read seldom you can add the `gnus-summary-bubble-group' function to
  1146. the `gnus-summary-exit-hook' hook.  This will result (after sorting) in
  1147. a bubbling sort of action.  If you want to see that in action after
  1148. each summary exit, you can add `gnus-group-sort-groups-by-rank' or
  1149. `gnus-group-sort-groups-by-score' to the same hook, but that will slow
  1150. things down somewhat.
  1151.  
  1152. 
  1153. File: gnus.info,  Node: Marking Groups,  Next: Foreign Groups,  Prev: Group Score,  Up: The Group Buffer
  1154.  
  1155. Marking Groups
  1156. ==============
  1157.  
  1158.    If you want to perform some command on several groups, and they
  1159. appear subsequently in the group buffer, you would normally just give a
  1160. numerical prefix to the command.  Most group commands will then do your
  1161. bidding on those groups.
  1162.  
  1163.    However, if the groups are not in sequential order, you can still
  1164. perform a command on several groups.  You simply mark the groups first
  1165. with the process mark and then execute the command.
  1166.  
  1167. `#'
  1168. `M m'
  1169.      Set the mark on the current group (`gnus-group-mark-group').
  1170.  
  1171. `M-#'
  1172. `M u'
  1173.      Remove the mark from the current group (`gnus-group-unmark-group').
  1174.  
  1175. `M U'
  1176.      Remove the mark from all groups (`gnus-group-unmark-all-groups').
  1177.  
  1178. `M w'
  1179.      Mark all groups between point and mark (`gnus-group-mark-region').
  1180.  
  1181. `M b'
  1182.      Mark all groups in the buffer (`gnus-group-mark-buffer').
  1183.  
  1184. `M r'
  1185.      Mark all groups that match some regular expression
  1186.      (`gnus-group-mark-regexp').
  1187.  
  1188.    Also *note Process/Prefix::..
  1189.  
  1190.    If you want to execute some command on all groups that have been
  1191. marked with the process mark, you can use the `M-&'
  1192. (`gnus-group-universal-argument') command.  It will prompt you for the
  1193. command to be executed.
  1194.  
  1195. 
  1196. File: gnus.info,  Node: Foreign Groups,  Next: Group Parameters,  Prev: Marking Groups,  Up: The Group Buffer
  1197.  
  1198. Foreign Groups
  1199. ==============
  1200.  
  1201.    Below are some group mode commands for making and editing general
  1202. foreign groups, as well as commands to ease the creation of a few
  1203. special-purpose groups.  All these commands insert the newly created
  1204. groups under point--`gnus-subscribe-newsgroup-method' is not consulted.
  1205.  
  1206. `G m'
  1207.      Make a new group (`gnus-group-make-group').  Gnus will prompt you
  1208.      for a name, a method and possibly an "address".  For an easier way
  1209.      to subscribe to NNTP groups, *note Browse Foreign Server::..
  1210.  
  1211. `G r'
  1212.      Rename the current group to something else
  1213.      (`gnus-group-rename-group').  This is legal only on some
  1214.      groups--mail groups mostly.  This command might very well be quite
  1215.      slow on some backends.
  1216.  
  1217. `G c'
  1218.      Customize the group parameters (`gnus-group-customize').
  1219.  
  1220. `G e'
  1221.      Enter a buffer where you can edit the select method of the current
  1222.      group (`gnus-group-edit-group-method').
  1223.  
  1224. `G p'
  1225.      Enter a buffer where you can edit the group parameters
  1226.      (`gnus-group-edit-group-parameters').
  1227.  
  1228. `G E'
  1229.      Enter a buffer where you can edit the group info
  1230.      (`gnus-group-edit-group').
  1231.  
  1232. `G d'
  1233.      Make a directory group (*note Directory Groups::.).  You will be
  1234.      prompted for a directory name (`gnus-group-make-directory-group').
  1235.  
  1236. `G h'
  1237.      Make the Gnus help group (`gnus-group-make-help-group').
  1238.  
  1239. `G a'
  1240.      Make a Gnus archive group (`gnus-group-make-archive-group').  By
  1241.      default a group pointing to the most recent articles will be
  1242.      created (`gnus-group-recent-archive-directory'), but given a
  1243.      prefix, a full group will be created from
  1244.      `gnus-group-archive-directory'.
  1245.  
  1246. `G k'
  1247.      Make a kiboze group.  You will be prompted for a name, for a
  1248.      regexp to match groups to be "included" in the kiboze group, and a
  1249.      series of strings to match on headers
  1250.      (`gnus-group-make-kiboze-group').  *Note Kibozed Groups::.
  1251.  
  1252. `G D'
  1253.      Read an arbitrary directory as if it were a newsgroup with the
  1254.      `nneething' backend (`gnus-group-enter-directory').  *Note
  1255.      Anything Groups::.
  1256.  
  1257. `G f'
  1258.      Make a group based on some file or other
  1259.      (`gnus-group-make-doc-group').  If you give a prefix to this
  1260.      command, you will be prompted for a file name and a file type.
  1261.      Currently supported types are `babyl', `mbox', `digest', `mmdf',
  1262.      `news', `rnews', `clari-briefs', `rfc934', `rfc822-forward', and
  1263.      `forward'.  If you run this command without a prefix, Gnus will
  1264.      guess at the file type.  *Note Document Groups::.
  1265.  
  1266. `G w'
  1267.      Make an ephemeral group based on a web search
  1268.      (`gnus-group-make-web-group').  If you give a prefix to this
  1269.      command, make a solid group instead.  You will be prompted for the
  1270.      search engine type and the search string.  Legal search engine
  1271.      types include `dejanews', `altavista' and `reference'.  *Note Web
  1272.      Searches::.
  1273.  
  1274. `G DEL'
  1275.      This function will delete the current group
  1276.      (`gnus-group-delete-group').  If given a prefix, this function will
  1277.      actually delete all the articles in the group, and forcibly remove
  1278.      the group itself from the face of the Earth.  Use a prefix only if
  1279.      you are absolutely sure of what you are doing.
  1280.  
  1281. `G V'
  1282.      Make a new, fresh, empty `nnvirtual' group
  1283.      (`gnus-group-make-empty-virtual').  *Note Virtual Groups::.
  1284.  
  1285. `G v'
  1286.      Add the current group to an `nnvirtual' group
  1287.      (`gnus-group-add-to-virtual').  Uses the process/prefix convention.
  1288.  
  1289.    *Note Select Methods:: for more information on the various select
  1290. methods.
  1291.  
  1292.    If `gnus-activate-foreign-newsgroups' is a positive number, Gnus
  1293. will check all foreign groups with this level or lower at startup.
  1294. This might take quite a while, especially if you subscribe to lots of
  1295. groups from different NNTP servers.
  1296.  
  1297.